34.a===1&&a===2&&a===3 为 true

隐式转化、对象劫持

• 知识点
  • == 双等号，隐式的类型转化 toPrimitive > valueOf > toString
  • === 全等号，不触发隐式的类型转化

双等号 == 会触发隐式转化调用 valueOf

class A {
  constructor(value) {
    this.value = value;
  }
  valueOf() {
    return this.value++;
  }
}
const a = new A(1);
if (a == 1 && a == 2 && a == 3) {
  console.log("Hi Libai!");
}

全等号，不会出发隐式转化

let obj = {};
let value = 1;
Object.defineProperty(obj, "a", {
  get() {
    return value++;
  },
});
if (obj.a === 1 && obj.a === 2 && obj.a === 3) {
  console.log("Hi Libai!");
}

// var value = 0;
// Object.defineProperty(window, 'a', {
//     get: function() {
//         return this.value += 1;
//     }
// });
// console.log(a===1 && a===2 && a===3) // true

二者并存的情况下，在数值运算中，优先调用了 valueOf，字符串运算中，优先调用了 toString。

[Symbol.toPrimitive]

优先级要高于 valueOf 和 toString

let a = {
  [Symbol.toPrimitive]: (function () {
    let i = 1;
    return () => i++;
  })(),
};
if (a == 1 && a == 2 && a == 3) {
  console.log("成功");
}

proxy

let a = new Proxy(
  {},
  {
    i: 1,
    get() {
      return () => this.i++;
    },
  }
);
if (a == 1 && a == 2 && a == 3) {
  console.log("成功");
}

tostring

var a = {
  count: 1,
  toString() {
    return this.count++;
  },
  /* valueOf(){
        return this.count++;
    } */
};
if (a == 1 && a == 2 && a == 3) {
  console.log("成功");
}